//package com.pkx.guide.timing;
//
//import com.pkx.guide.info.entity.ProducerQest;
//import com.pkx.guide.info.service.TInfoGuideStatusService;
//import com.pkx.guide.info.service.TInfoNetworkConfigService;
//import com.pkx.guide.qianfeng.service.QianFengSocketService;
//import jakarta.annotation.Resource;
//import org.springframework.context.annotation.Bean;
//import org.springframework.stereotype.Component;
//
//import java.nio.charset.StandardCharsets;
//import java.util.concurrent.ArrayBlockingQueue;
//import java.util.concurrent.BlockingQueue;
//import java.util.concurrent.CompletableFuture;
//
//@Slf4j
//@Component
//public class ProducerConsumerDemo {
//
//    private final BlockingQueue<ProducerQest> dataQueue = new ArrayBlockingQueue<>(1);
//
//    // 添加重试计数器
//    private int retryCount = 0;
//    private static final int MAX_RETRY_COUNT = 3;
//
//    @Resource
//    private TInfoGuideStatusService tInfoGuideStatusService;
//    @Resource
//    private QianFengSocketService qianFengSocketService;
//    @Resource
//    private TInfoNetworkConfigService infoNetworkConfigService;
//
//    private Thread consumerThread;
//    private static Socket socket;
//
//    @Bean
//    private void startConsumer() {
//        if (consumerThread == null || !consumerThread.isAlive()) {
//            synchronized (this) {
//                if (consumerThread == null || !consumerThread.isAlive()) {
//                    consumerThread = new Thread(() -> {
//                        try {
//                            // 在消费者线程启动时执行一次设备连接检查
//                            if (!checkQianFengDeviceAndPublishWithRetry()) {
//                                log.error("设备连接检查失败，超过最大重试次数: {}", MAX_RETRY_COUNT);
//                                return;
//                            }
//
//                            while (!Thread.currentThread().isInterrupted()) {
//                                ProducerQest qest = dataQueue.take();
//                                handleProducerWithRetry(qest);
//                            }
//                        } catch (InterruptedException e) {
//                            Thread.currentThread().interrupt();
//                            System.out.println("消费者线程被中断");
//                        } catch (Exception e) {
//                            System.err.println("消费者处理异常：" + e.getMessage());
//                        }
//                    }, "Producer-Consumer-Thread");
//
//                    consumerThread.setDaemon(true);
//                    consumerThread.start();
//                    System.out.println("消费者线程启动成功");
//                }
//            }
//        }
//    }
//
//    // 带重试机制的连接检查方法
//    private boolean checkQianFengDeviceAndPublishWithRetry() {
//        while (retryCount < MAX_RETRY_COUNT) {
//            try {
//                checkQianFengDeviceAndPublish();
//                retryCount = 0; // 成功后重置计数器
//                return true;
//            } catch (Exception e) {
//                retryCount++;
//                log.error("设备连接检查失败，第{}次重试: {}", retryCount, e.getMessage());
//                if (retryCount >= MAX_RETRY_COUNT) {
//                    log.error("设备连接检查失败，已达到最大重试次数: {}", MAX_RETRY_COUNT);
//                    return false;
//                }
//                try {
//                    Thread.sleep(1000); // 等待1秒后重试
//                } catch (InterruptedException ie) {
//                    Thread.currentThread().interrupt();
//                    return false;
//                }
//            }
//        }
//        return false;
//    }
//
//    private void checkQianFengDeviceAndPublish() throws Exception {
//        socket = qianFengSocketService.create("127.0.0.1", 8080);
//        if (socket == null || socket.isClosed()) {
//            log.error("创建连接失败");
//            throw new Exception("Socket连接创建失败");
//        } else {
//            log.info("创建连接成功");
//        }
//    }
//
//    // 带重试机制的处理方法
//    private void handleProducerWithRetry(ProducerQest qest) {
//        int handleRetryCount = 0;
//        while (handleRetryCount < MAX_RETRY_COUNT) {
//            try {
//                handleProducer(qest);
//                return; // 成功处理后直接返回
//            } catch (Exception e) {
//                handleRetryCount++;
//                log.error("处理ProducerQest失败，第{}次重试: {}", handleRetryCount, e.getMessage());
//                if (handleRetryCount >= MAX_RETRY_COUNT) {
//                    log.error("处理ProducerQest失败，已达到最大重试次数: {}", MAX_RETRY_COUNT);
//                    // 可以在这里进行额外的错误处理
//                    handleProducerFailure(qest, e);
//                }
//                try {
//                    Thread.sleep(1000); // 等待1秒后重试
//                } catch (InterruptedException ie) {
//                    Thread.currentThread().interrupt();
//                    return;
//                }
//            }
//        }
//    }
//
//    // 处理业务的方法
//    private void handleProducer(ProducerQest qest) throws Exception {
//        try {
//            String ipList = qest.getIpList();
//            int ipListSize = qest.getIpListSize();
//            byte[] params = ipList.getBytes(StandardCharsets.UTF_8);
//            socket.(2000);
//            qianFengSocketService.send(params, socket);
//            socket.setSoTimeout(ipListSize*2000);
//            byte[] resultArr = qianFengSocketService.receive(socket);
//            String result = new String(resultArr, StandardCharsets.UTF_8).trim();
//
//            // 更新状态
//            tInfoGuideStatusService.updateGuideStatus(result);
//
//            // 总是返回结果
//            CompletableFuture<String> future = qest.getCompletionFuture();
//            if (future != null && !future.isDone()) {
//                future.complete(result);
//            }
//
//        } catch (Exception e) {
//            // 总是返回异常
//            CompletableFuture<String> future = qest.getCompletionFuture();
//            if (future != null && !future.isDone()) {
//                future.completeExceptionally(e);
//            }
//            throw e;
//        }
//    }
//
//    // 处理最终失败的情况
//    private void handleProducerFailure(ProducerQest qest, Exception e) {
//        log.error("ProducerQest处理最终失败，任务ID: {}, 错误信息: {}",
//                  qest.getTask() != null ? qest.getTask().getId() : "unknown",
//                  e.getMessage());
//        // 可以在这里添加更多的错误处理逻辑，比如记录到数据库或发送告警
//    }
//}